package cn.fzkj.framework.security.service;

import cn.fzkj.common.utils.ServletUtils;
import cn.fzkj.common.utils.StringUtil;
import cn.fzkj.framework.security.LoginUser;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.AuthorityUtils;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.util.*;
import java.util.stream.Collectors;

/**
 * 自定义权限实现
 */
@Service("ss")
public class PermissionService {

    /** 所有权限标识 */
    private static final String ALL_PERMISSION = "ADMIN";

    /** 管理员角色权限标识 */
    private static final String SUPER_ADMIN = "admin";

    private static final String ROLE_DELIMETER = ",";

    private static final String PERMISSION_DELIMETER = ",";

    @Autowired
    private TokenService tokenService;

    /**
     * 验证用户是否具备某权限
     *
     * @param permission 权限字符串
     * @return 用户是否具备某权限
     */
    public boolean hasPermi(String permission)
    {
        System.out.println("================ 执行到自定义的权限认证中 =============");
        if (StringUtil.isEmpty(permission)){
            return false;
        }
        LoginUser loginUser = tokenService.getLoginUser(ServletUtils.getRequest());
        if (StringUtil.isNull(loginUser) || CollectionUtils.isEmpty(loginUser.getAuthorities())) {
            return false;
        }
        Collection<? extends GrantedAuthority> authorities = loginUser.getAuthorities();
        return hasPermissions(authorities, permission);
    }

    /**
     * 验证用户是否不具备某权限，与 hasPermi逻辑相反
     *
     * @param permission 权限字符串
     * @return 用户是否不具备某权限
     */
    public boolean lacksPermi(String permission)
    {
        return hasPermi(permission) != true;
    }

    /**
     * 判断用户是否拥有某个角色
     *
     * @param role 角色字符串
     * @return 用户是否具备某角色
     */
//    public boolean hasRole(String role)
//    {
//        if (StringUtils.isEmpty(role))
//        {
//            return false;
//        }
//        LoginUser loginUser = tokenService.getLoginUser(ServletUtils.getRequest());
//        if (StringUtil.isNull(loginUser) || CollectionUtils.isEmpty(loginUser.getUser().getRoles()))
//        {
//            return false;
//        }
//        for (SysRole sysRole : loginUser.getUser().getRoles())
//        {
//            String roleKey = sysRole.getRoleKey();
//            if (SUPER_ADMIN.contains(roleKey) || roleKey.contains(StringUtils.trim(role)))
//            {
//                return true;
//            }
//        }
//        return false;
//    }

    /**
     * 验证用户是否不具备某角色，与 isRole逻辑相反。
     *
     * @param role 角色名称
     * @return 用户是否不具备某角色
     */
//    public boolean lacksRole(String role)
//    {
//        return hasRole(role) != true;
//    }

    /**
     * 验证用户是否具有以下任意一个角色
     *
     * @param roles 以 ROLE_NAMES_DELIMETER 为分隔符的角色列表
     * @return 用户是否具有以下任意一个角色
     */
//    public boolean hasAnyRoles(String roles)
//    {
//        if (StringUtils.isEmpty(roles))
//        {
//            return false;
//        }
//        LoginUser loginUser = tokenService.getLoginUser(ServletUtils.getRequest());
//        if (StringUtil.isNull(loginUser) || loginUser.getUser().getUserType() == null)
//        {
//            return false;
//        }
//        for (String role : roles.split(ROLE_DELIMETER))
//        {
//            if (hasRole(role))
//            {
//                return true;
//            }
//        }
//        return false;
//    }

    /**
     * 判断是否包含权限
     *
     * @param permissions 权限列表
     * @param permission 权限字符串
     * @return 用户是否具备某权限
     */
    private boolean hasPermissions(Collection<? extends GrantedAuthority> permissions, String permission) {
        if (permissions.stream()
                .map(perm->((GrantedAuthority) perm).getAuthority())
                .collect(Collectors.toList()).contains(ALL_PERMISSION))
            return true;
        return permissions.stream()
                .map(perm->((GrantedAuthority) perm).getAuthority().equals(permission))
                .collect(Collectors.toList())
                .contains(true);
    }

//    public static void main(String[] args) {
//        Collection<? extends GrantedAuthority> permissions = AuthorityUtils.commaSeparatedStringToAuthorityList("USER,ADMIN");
//        permissions.forEach(System.out::println);
//        System.out.println("\n"+permissions.contains("ADMIN")); // 因为集合中的元素和"ADMIN"类型不对
//        boolean admin = permissions.stream().map(perm -> ((GrantedAuthority) perm).getAuthority().equals("ADMIN")).collect(Collectors.toList()).contains(true);
//        System.out.println(admin);
//    }

}
